/**
 * 数组工具函数集合
 * 提供常用的数组操作工具函数
 */

/**
 * 从数组中找出最小值
 * @param {Array} array - 输入数组
 * @param {Function} [valueSelector] - 值选择器函数，可选
 * @returns {*} - 数组中的最小值
 */
export const findMin = (array, valueSelector = null) => {
  if (!array || array.length === 0) return undefined;
  
  if (valueSelector) {
    return array.reduce((min, current) => {
      const currentValue = valueSelector(current);
      const minValue = valueSelector(min);
      return currentValue < minValue ? current : min;
    });
  } else {
    return Math.min(...array);
  }
};

/**
 * 从数组中找出最大值
 * @param {Array} array - 输入数组
 * @param {Function} [valueSelector] - 值选择器函数，可选
 * @returns {*} - 数组中的最大值
 */
export const findMax = (array, valueSelector = null) => {
  if (!array || array.length === 0) return undefined;
  
  if (valueSelector) {
    return array.reduce((max, current) => {
      const currentValue = valueSelector(current);
      const maxValue = valueSelector(max);
      return currentValue > maxValue ? current : max;
    });
  } else {
    return Math.max(...array);
  }
};

/**
 * 计算数组的平均值
 * @param {Array} array - 输入数组
 * @param {Function} [valueSelector] - 值选择器函数，可选
 * @returns {number} - 数组的平均值
 */
export const calculateAverage = (array, valueSelector = null) => {
  if (!array || array.length === 0) return 0;
  
  const values = valueSelector ? array.map(valueSelector) : array;
  const sum = values.reduce((acc, val) => acc + val, 0);
  return sum / values.length;
};

/**
 * 对数组进行去重
 * @param {Array} array - 输入数组
 * @param {Function} [keySelector] - 键选择器函数，可选
 * @returns {Array} - 去重后的数组
 */
export const unique = (array, keySelector = null) => {
  if (!array || array.length === 0) return [];
  
  if (keySelector) {
    const seen = new Set();
    return array.filter(item => {
      const key = keySelector(item);
      if (seen.has(key)) {
        return false;
      }
      seen.add(key);
      return true;
    });
  } else {
    return [...new Set(array)];
  }
};

/**
 * 对数组进行分组
 * @param {Array} array - 输入数组
 * @param {Function} keySelector - 分组键选择器函数
 * @returns {Object} - 分组后的对象
 */
export const groupBy = (array, keySelector) => {
  if (!array || array.length === 0) return {};
  
  return array.reduce((groups, item) => {
    const key = keySelector(item);
    if (!groups[key]) {
      groups[key] = [];
    }
    groups[key].push(item);
    return groups;
  }, {});
};

/**
 * 对数组进行排序
 * @param {Array} array - 输入数组
 * @param {Function} [comparator] - 比较函数，可选
 * @param {boolean} [descending=false] - 是否降序排列
 * @returns {Array} - 排序后的数组
 */
export const sortArray = (array, comparator = null, descending = false) => {
  if (!array || array.length === 0) return [];
  
  const sorted = [...array];
  
  if (comparator) {
    sorted.sort(comparator);
  } else {
    sorted.sort((a, b) => a - b);
  }
  
  return descending ? sorted.reverse() : sorted;
};

/**
 * 过滤数组中的有效值（去除null、undefined、空字符串等）
 * @param {Array} array - 输入数组
 * @returns {Array} - 过滤后的数组
 */
export const filterValid = (array) => {
  if (!array) return [];
  return array.filter(item => 
    item !== null && 
    item !== undefined && 
    item !== '' && 
    !Number.isNaN(item)
  );
};

/**
 * 数组工具函数集合的默认导出
 */
export default {
  findMin,
  findMax,
  calculateAverage,
  unique,
  groupBy,
  sortArray,
  filterValid
};